package com.example.utils;

import java.text.SimpleDateFormat;
import java.util.Date;

/***
 * 提供用于时间日期字符串验证、格式化和转换的工具方法。
 */
public class FormatUtils {
    // =======================================================================================
    // ================================验证字符串是否为日期格式，并格式化=============================
    // =======================================================================================

    /**
     * 检验字符串是否为有效的日期格式
     * 该方法支持多种日期格式的检查，包括：
     * yyyyMMdd、yyyy-MM-dd、yyyy/MM/dd、yyyy-MM、yyyy/MM、yyyyMM
     * 如果字符串符合上述任一日期格式，则返回true；否则返回false
     *
     * @param str 待检验的字符串
     * @return 如果字符串为有效的日期格式，则返回true；否则返回false
     */
    public static boolean isDateLean(String str) {
        // 验证字符串是否为日期格式(yyyyMMdd)
        if (isDate1(str) == true) {
            return true;
        } else if (isDate2(str) == true) {
            // 验证字符串是否为日期格式(yyyy-MM-dd)
            return true;
        } else if (isDate3(str) == true) {
            // 验证字符串是否为日期格式(yyyy/MM/dd)
            return true;
        } else if (isDate4(str) == true) {
            // 验证字符串是否为日期格式(yyyy-MM)
            return true;
        } else if (isDate5(str) == true) {
            // 验证字符串是否为日期格式(yyyy/MM)
            return true;
        } else if (isDate6(str) == true) {
            // 验证字符串是否为日期格式(yyyyMM)
            return true;
        } else {
            // 如果字符串不符合上述任何一种日期格式，则返回false
            return false;
        }
    }


    /**
     * 验证字符串是否为有效的日期格式，并将其转换为相应的格式
     * 此方法不直接操作日期对象，而是基于字符串格式进行判断和转换
     * 它通过一系列的条件判断来确定输入字符串符合哪种日期格式，并将其转换为该格式的标准表示
     * 如果输入字符串不符合任何预定义的日期格式，则原样返回
     *
     * @param date 待验证的日期字符串
     * @return 根据输入字符串的内容，返回转换后的日期字符串或原字符串
     * @throws Exception 如果日期格式转换过程中发生错误，则抛出异常
     */
    public static String isDateFormat(String date) throws Exception {
        // 验证字符串是否为日期格式(yyyyMMdd)
        if (isDate1(date) == true) {
            return getFormat4(setFormat4(date));
            // 验证字符串是否为日期格式(yyyy-MM-dd)
        } else if (isDate2(date) == true) {
            return getFormat6(setFormat6(date));
            // 验证字符串是否为日期格式(yyyy/MM/dd)
        } else if (isDate3(date) == true) {
            return getFormat5(setFormat5(date));

            // 验证字符串是否为日期格式(yyyy-MM)
        } else if (isDate4(date) == true) {
            return getFormat2(setFormat2(date));

            // 验证字符串是否为日期格式(yyyy/MM)
        } else if (isDate5(date) == true) {
            return getFormat3(setFormat3(date));
            // 验证字符串是否为日期格式(yyyyMM)
        } else if (isDate6(date) == true) {
            return getFormat1(setFormat1(date));
        }
        // 如果字符串不符合任何预定义的日期格式，则原样返回
        return date;
    }

    // =======================================================================================
    // ================================验证字符串是否为时间格式，并格式化===========================
    // =======================================================================================

    /**
     * 检验字符串是否符合时间格式
     * 该方法依次尝试通过四个不同的时间格式检查字符串如果字符串符合其中任何一个格式，则返回true；否则返回false
     * 此方法不直接用于业务逻辑，而是用于验证和格式化输入字符串是否为有效的时间表示
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合任一时间格式，则返回true；否则返回false
     */
    public static boolean isTimeLean(String str) {
        if (isTime1(str) == true) {
            // 验证字符串是否为时间格式(HHmm)
            return true;
        } else if (isTime2(str) == true) {
            // 验证字符串是否为时间格式(HHmmss)
            return true;
            // 尝试用第三个时间格式验证字符串
        } else if (isTime3(str) == true) {
            // 验证字符串是否为时间格式(HH:mm)
            return true;
        } else if (isTime4(str) == true) {
            // 验证字符串是否为时间格式(HH:mm:ss)
            return true;
        } else {
            // 如果所有格式都不匹配，则返回false
            return false;
        }
    }

    public static String isTimeFormat(String date) throws Exception {
        if (isTime1(date) == true) {
            // 验证字符串是否为时间格式(HHmm)
            return getTime1(setTime1(date));
        } else if (isTime2(date) == true) {
            // 验证字符串是否为时间格式(HHmmss)
            return getTime2(setTime2(date));
        } else if (isTime3(date) == true) {
            // 验证字符串是否为时间格式(HH:mm)
            return getTime3(setTime3(date));
        } else if (isTime4(date) == true) {
            // 验证字符串是否为时间格式(HH:mm:ss)
            return getTime4(setTime4(date));
        }
        return date;
    }

    // =======================================================================================
    // ================================验证字符串是否为日期格式，并格式化===========================
    // =======================================================================================

    /**
     * 判断字符串是否为日期时间格式
     * 该方法通过调用多个日期时间验证方法来判断输入字符串是否符合任一日期时间格式
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合任一日期时间格式，则返回true；否则返回false
     */
    public static boolean isDateTimeLean(String str) {
        // 检查字符串是否符合第一种日期时间格式
        if (isDateTime1(str) == true) {
            return true;
        }
        // 检查字符串是否符合第二种日期时间格式
        else if (isDateTime2(str) == true) {
            return true;
        }
        // 检查字符串是否符合第三种日期时间格式
        else if (isDateTime3(str) == true) {
            return true;
        }
        // 检查字符串是否符合第四种日期时间格式
        else if (isDateTime4(str) == true) {
            return true;
        }
        // 如果字符串不符合任何一种日期时间格式，则返回false
        else {
            return false;
        }
    }

    /**
     * 判断并转换日期字符串为特定格式
     * 此方法旨在检查输入的日期字符串符合哪种预定义的日期时间格式，并将其转换为对应的标准格式
     * 如果日期字符串不符合任何预定义格式，则原样返回
     *
     * @param date 日期字符串，待检查和转换的输入
     * @return 转换后的日期字符串，如果不符合任何预定义格式则原样返回
     * @throws Exception 如果日期字符串无法被解析为任何预定义的日期时间格式，则抛出异常
     */
    public static String isTimeFormatFormat(String date) throws Exception {
        // 检查日期时间格式是否为(yyyyMMddhhmm)
        if (isDateTime1(date) == true) {
            // 验证字符串是否为日期时间格式(yyyyMMddHHmm)
            return getFormat8(setFormat8(date));
        } else if (isDateTime2(date) == true) {
            // 验证字符串是否为日期时间格式(yyyy-MM-dd HH:mm)
            return getFormat9(setFormat9(date));
        } else if (isDateTime3(date) == true) {
            // 验证字符串是否为日期时间格式(yyyyMMddHHmmss)
            return getFormat7(setFormat7(date));
        } else if (isDateTime4(date) == true) {
            // 验证字符串是否为日期时间格式(yyyy-MM-dd HH:mm:ss)
            return getFormat10(setFormat10(date));
        }
        // 如果日期字符串不符合任何预定义格式，则原样返回
        return date;
    }

    // =======================================================================================
    // ================================验证字符串是否为日期格式===================================
    // =======================================================================================

    /**
     * 验证字符串是否为日期格式(yyyyMMdd)
     */
    public static boolean isDate1(String str) {
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        try {
            format.setLenient(false);
            format.parse(str);
        } catch (Exception e) {
            // 不是日期格式
            return false;
        }
        return true;
    }

    /**
     * 验证字符串是否为日期格式(yyyy-MM-dd)
     * 该方法用于判断给定的字符串是否符合"yyyy-MM-dd"日期格式
     * 它通过尝试解析字符串为日期来验证格式，如果解析成功则认为字符串是有效的日期格式
     *
     * @param str 待验证的字符串
     * @return 如果字符串是有效的日期格式，则返回true；否则返回false
     */
    public static boolean isDate2(String str) {
        // 创建一个SimpleDateFormat实例，用于解析日期
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        try {
            // 设置解析严格模式为false，以确保日期必须严格符合格式
            format.setLenient(false);
            // 尝试解析字符串为日期
            format.parse(str);
        } catch (Exception e) {
            // 如果解析过程中抛出异常，则说明字符串不是有效的日期格式
            return false;
        }
        // 如果解析成功，则返回true
        return true;
    }

    /**
     * 验证字符串是否为日期格式(yyyy/MM/dd)
     * 此方法用于检查传入的字符串是否符合特定的日期格式，
     * 以确保数据的一致性和准确性
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合日期格式(yyyy / MM / dd)，则返回true；否则返回false
     */
    public static boolean isDate3(String str) {
        // 创建SimpleDateFormat实例，用于解析和格式化日期
        SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd");
        try {
            // 设置解析严格模式，确保日期必须完全匹配格式
            format.setLenient(false);
            // 尝试解析字符串为日期，如果不符合格式将抛出异常
            format.parse(str);
        } catch (Exception e) {
            // 捕获异常，表示字符串不是有效的日期格式
            return false;
        }
        // 如果没有抛出异常，表示字符串是有效的日期格式
        return true;
    }

    /**
     * 验证字符串是否为日期格式(yyyy-MM)
     * 此方法用于检查传入的字符串是否符合"yyyy-MM"的日期格式
     * 它通过尝试将字符串解析为日期对象来实现，如果解析过程中抛出异常，则说明字符串格式不正确
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合日期格式(yyyy - MM)，则返回true；否则返回false
     */
    public static boolean isDate4(String str) {
        // 创建SimpleDateFormat实例，用于解析日期字符串
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
        try {
            // 设置解析为严格模式，以确保日期必须完全匹配格式
            format.setLenient(false);
            // 尝试解析字符串为日期对象
            format.parse(str);
        } catch (Exception e) {
            // 如果抛出异常，则说明字符串不是日期格式
            return false;
        }
        // 如果没有抛出异常，则说明字符串是日期格式
        return true;
    }

    /**
     * 验证字符串是否为日期格式(yyyy/MM)
     * 此方法用于检查输入的字符串是否符合特定的日期格式，
     * 即年份后跟月份，年份和月份之间用斜杠(/)分隔。
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合日期格式(yyyy / MM)，则返回true；否则返回false。
     */
    public static boolean isDate5(String str) {
        // 创建SimpleDateFormat对象，并设置日期格式为"yyyy/MM"
        SimpleDateFormat format = new SimpleDateFormat("yyyy/MM");
        try {
            // 设置解析日期时的宽松程度为false，以确保日期必须严格符合指定格式
            format.setLenient(false);
            // 尝试解析输入字符串为日期，如果解析成功且没有抛出异常，
            // 说明输入字符串符合指定的日期格式
            format.parse(str);
        } catch (Exception e) {
            // 如果解析过程中抛出异常，说明输入字符串不是日期格式(yyyy/MM)
            return false;
        }
        // 如果没有抛出异常，说明输入字符串是日期格式(yyyy/MM)
        return true;
    }

    /**
     * 验证字符串是否为日期格式(yyyyMM)
     * 此方法用于检查给定的字符串是否符合"yyyyMM"的日期格式，
     * 其中yyyy代表年份，MM代表月份。
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合日期格式，则返回true；否则返回false。
     */
    public static boolean isDate6(String str) {
        // 创建SimpleDateFormat对象，并设置日期格式为"yyyyMM"
        SimpleDateFormat format = new SimpleDateFormat("yyyyMM");
        try {
            // 设置解析日期时的宽松度为false，以确保日期必须严格符合指定格式
            format.setLenient(false);
            // 尝试解析字符串为日期，如果不符合格式，则抛出异常
            format.parse(str);
        } catch (Exception e) {
            // 当字符串不是日期格式时，捕获异常并返回false
            return false;
        }
        // 如果字符串成功解析为日期，则返回true
        return true;
    }

    // =======================================================================================
    // ================================验证字符串是否为时间格式===================================
    // =======================================================================================

    /**
     * 验证字符串是否为时间格式(HHmm)
     * 此方法用于检查输入的字符串是否符合HHmm的时间格式，其中HH代表小时，mm代表分钟
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合时间格式，则返回true；否则返回false
     */
    public static boolean isTime1(String str) {
        // 创建SimpleDateFormat实例，用于解析时间字符串
        SimpleDateFormat format = new SimpleDateFormat("HHmm");
        try {
            // 设置解析为严格模式，以确保时间必须严格符合格式
            format.setLenient(false);
            // 尝试解析字符串为时间格式
            format.parse(str);
        } catch (Exception e) {
            // 如果解析过程中抛出异常，则说明字符串不是时间格式
            return false;
        }
        // 如果解析成功，则说明字符串是时间格式
        return true;
    }

    /**
     * 验证字符串是否为时间格式(HHmmss)
     * 此方法用于检查输入的字符串是否符合HHmmss时间格式，其中：
     * HH代表24小时制的小时数，mm代表分钟，ss代表秒数
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合时间格式，则返回true；否则返回false
     */
    public static boolean isTime2(String str) {
        // 创建SimpleDateFormat实例，用于解析时间字符串
        SimpleDateFormat format = new SimpleDateFormat("HHmmss");
        try {
            // 设置解析严格模式，确保时间必须严格符合格式
            format.setLenient(false);
            // 尝试解析字符串为时间格式
            format.parse(str);
        } catch (Exception e) {
            // 如果解析过程中抛出异常，则说明字符串不是时间格式
            return false;
        }
        // 如果解析成功，则说明字符串是时间格式
        return true;
    }

    /**
     * 验证字符串是否为时间格式(HH:mm)
     * 该方法用于判断输入的字符串是否符合HH:mm的时间格式，其中HH代表24小时制小时数，mm代表分钟
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合时间格式，则返回true；否则返回false
     */
    public static boolean isTime3(String str) {
        // 创建SimpleDateFormat实例，用于解析时间字符串
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        try {
            // 设置解析严格模式，确保时间必须严格符合格式
            format.setLenient(false);
            // 尝试解析字符串为时间格式，如果不符合格式将抛出异常
            format.parse(str);
        } catch (Exception e) {
            // 不是时间格式
            return false;
        }
        return true;
    }

    /**
     * 验证字符串是否为时间格式(HH:mm:ss)
     * 此方法用于检查一个字符串是否符合HH:mm:ss格式的时间表示形式
     * 它通过尝试将字符串解析为指定的时间格式来实现，如果解析过程中抛出异常，则说明字符串不符合指定格式
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合HH:mm:ss格式，则返回true；否则返回false
     */
    public static boolean isTime4(String str) {
        // 创建一个SimpleDateFormat实例，用于解析时间字符串
        SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
        try {
            // 设置解析为严格模式，以确保时间字符串必须严格符合HH:mm:ss格式
            format.setLenient(false);
            // 尝试解析传入的字符串，如果字符串不符合格式，此处会抛出ParseException异常
            format.parse(str);
        } catch (Exception e) {
            // 当捕获到异常时，说明字符串不是符合HH:mm:ss格式的时间表示
            return false;
        }
        // 如果没有抛出异常，说明字符串符合时间格式，返回true
        return true;
    }

    // =======================================================================================
    // ================================验证字符串是否为日期时间格式================================
    // =======================================================================================

    /**
     * 验证字符串是否为日期时间格式(yyyyMMddhhmm)
     * 此方法用于检查输入的字符串是否符合指定的日期时间格式，
     * 以确保数据的一致性和准确性
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合指定的日期时间格式，则返回true；否则返回false
     */
    public static boolean isDateTime1(String str) {
        // 创建SimpleDateFormat实例，指定日期时间格式
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddhhmm");
        try {
            // 设置解析日期的严格模式，以确保日期的有效性
            format.setLenient(false);
            // 尝试解析字符串为日期时间，如果不符合格式将抛出异常
            format.parse(str);
        } catch (Exception e) {
            // 不是时间格式
            return false;
        }
        return true;
    }

    /**
     * 验证字符串是否为日期时间格式(yyyy-MM-dd HH:mm)
     * 该方法用于判断给定的字符串是否符合指定的日期时间格式
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合指定的日期时间格式，则返回true；否则返回false
     */
    public static boolean isDateTime2(String str) {
        // 创建SimpleDateFormat实例，指定日期时间格式
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        try {
            // 设置解析日期的严格模式，确保日期必须完全匹配格式
            format.setLenient(false);
            // 尝试解析字符串为日期时间，如果不符合格式将抛出异常
            format.parse(str);
        } catch (Exception e) {
            // 不是日期时间格式
            return false;
        }
        return true;
    }

    /**
     * 验证字符串是否为日期时间格式(yyyyMMddHHmmss)
     * 该方法用于检查输入的字符串是否符合指定的日期时间格式
     * 主要用于数据校验，确保日期时间数据的输入格式一致性
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合指定的日期时间格式，则返回true；否则返回false
     */
    public static boolean isDateTime3(String str) {
        // 创建SimpleDateFormat实例，用于解析和格式化日期时间
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
        try {
            // 设置解析的严格模式，确保日期时间必须严格符合格式
            format.setLenient(false);
            // 尝试解析字符串，如果符合格式则不会抛出异常
            format.parse(str);
        } catch (Exception e) {
            // 不是日期时间格式
            // 当输入的字符串不符合日期时间格式时，捕获异常并返回false
            return false;
        }
        // 如果没有抛出异常，说明字符串符合日期时间格式，返回true
        return true;
    }

    /**
     * 验证字符串是否为日期时间格式(yyyy-MM-dd HH:mm:ss)
     * 此方法用于检查给定的字符串是否符合指定的日期时间格式
     * 它通过尝试将字符串解析为日期时间对象来实现，如果解析过程中抛出异常，则说明字符串不符合指定格式
     *
     * @param str 待验证的字符串
     * @return 如果字符串符合指定的日期时间格式，则返回true；否则返回false
     */
    public static boolean isDateTime4(String str) {
        // 创建SimpleDateFormat实例，用于解析日期时间字符串
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            // 设置解析严格模式为false，以确保解析操作严格按照指定格式进行
            format.setLenient(false);
            // 尝试解析字符串，如果字符串符合指定格式，此行代码将成功执行
            format.parse(str);
        } catch (Exception e) {
            // 如果解析过程中抛出异常，说明字符串不符合指定的日期时间格式
            // 返回false表示验证失败
            return false;
        }
        // 如果解析成功，返回true表示验证成功
        return true;
    }
// =======================================================================================
    // ================================时间字符串格式化=======================================
    // =======================================================================================


    /**
     * 将Date对象格式化为字符串时间(HHmm)
     *
     * @param date 待格式化的Date对象
     * @return 格式化后的字符串时间
     */
    public static final String getTime1(Date date) {
        // 创建一个SimpleDateFormat对象，用于格式化时间
        SimpleDateFormat simp = new SimpleDateFormat("HHmm");
        // 使用SimpleDateFormat对象将Date格式化为字符串并返回
        return simp.format(date);
    }

    /**
     * 将Date对象转换为字符串时间格式(HHmmss)
     *
     * @param date Date对象，表示需要格式化的时间
     * @return 字符串表示的时间，格式为HHmmss
     */
    public static final String getTime2(Date date) {
        // 创建一个SimpleDateFormat对象，用于格式化时间
        SimpleDateFormat simp = new SimpleDateFormat("HHmmss");
        // 使用SimpleDateFormat对象将Date格式化为字符串并返回
        return simp.format(date);
    }

    /**
     * 字符串时间格式化(HH:mm )
     */
    public static final String getTime3(Date date) {
        SimpleDateFormat simp = new SimpleDateFormat("HH:mm");
        return simp.format(date);
    }

    /**
     * 将Date对象格式化为HH:mm:ss格式的字符串时间
     * 此方法用于获取时间的字符串表示，适用于需要显示时间但不需要日期的情况
     *
     * @param date Date对象，表示要格式化的时间点
     * @return 返回格式化后的时间字符串，格式为HH:mm:ss
     */
    public static final String getTime4(Date date) {
        // 创建SimpleDateFormat实例，用于格式化时间
        SimpleDateFormat simp = new SimpleDateFormat("HH:mm:ss");
        // 使用SimpleDateFormat实例格式化传入的Date对象，并返回格式化后的字符串时间
        return simp.format(date);
    }

    // =======================================================================================
    // ================================时间字符串转换===========================================
    // =======================================================================================

    /**
     * 将字符串时间格式转换为Date对象
     * 此方法专注于处理格式为小时和分钟的字符串时间
     * 主要用途是简化字符串时间到Date对象的转换过程，提高代码可读性和可维护性
     *
     * @param date 字符串时间，格式为"HHmm"
     * @return Date对象，表示输入的字符串时间
     * @throws Exception 如果字符串时间格式不正确或解析失败
     */
    public static final Date setTime1(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定时间格式为"hhmm"
        SimpleDateFormat simp = new SimpleDateFormat("HHmm");
        // 使用SimpleDateFormat实例解析输入的字符串时间，并返回Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串时间格式转换为Date对象
     * 此方法专注于处理时间格式为"HHmmss"的字符串，将其转换为对应的Date对象
     * 主要解决了在处理时间数据时需要统一格式的问题，使得后续处理更加便捷
     *
     * @param date 字符串时间，格式为"HHmmss"
     * @return Date对象，表示转换后的日期时间
     * @throws Exception 如果字符串格式不正确导致解析失败，将抛出异常
     */
    public static final Date setTime2(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定时间格式为"hhmmss"
        SimpleDateFormat simp = new SimpleDateFormat("HHmmss");
        // 将字符串时间解析为Date对象，并返回
        return simp.parse(date);
    }

    /**
     * 将字符串时间格式转换为Date对象
     * 该方法专门用于处理时间格式为"yyyy-MM-dd HH:mm"的字符串
     * 仅关注小时和分钟的解析，忽略年月日部分
     *
     * @param date 一个表示时间的字符串，格式为"yyyy-MM-dd HH:mm"
     * @return Date对象，表示给定字符串所表示的时间
     * @throws Exception 如果字符串格式不正确，无法解析为时间
     */
    public static final Date setTime3(String date) throws Exception {
        // 创建一个SimpleDateFormat对象，用于解析字符串中的小时和分钟
        SimpleDateFormat simp = new SimpleDateFormat("HH:mm");
        // 解析传入的日期字符串，返回对应的Date对象
        // 注意：此方法仅使用了字符串的小时和分钟部分，年月日信息将被忽略
        return simp.parse(date);
    }

    /**
     * 将字符串时间格式转换为Date对象
     * 该方法专注于将符合HH:mm:ss格式的字符串转换为对应的Date对象
     *
     * @param date 字符串时间，格式为HH:mm:ss
     * @return Date对象，表示输入的字符串时间
     * @throws Exception 如果字符串时间格式不正确或解析过程中出现错误
     */
    public static final Date setTime4(String date) throws Exception {
        // 创建SimpleDateFormat实例，用于解析字符串时间
        SimpleDateFormat simp = new SimpleDateFormat("HH:mm:ss");
        // 使用SimpleDateFormat实例解析输入的字符串时间并返回对应的Date对象
        return simp.parse(date);
    }


    // =======================================================================================
    // ==============================日期字符串格式化============================================
    // =======================================================================================

    /**
     * 日期字符串格式化
     * 该方法旨在将传入的日期字符串按照一定的格式进行转换，使其更易于阅读
     * 如果日期字符串的长度是8位，则假设它是年月日格式（YYYYMMDD），并将其格式化为YYYY-MM-DD
     * 如果日期字符串的长度是6位，则假设它是年月日格式（YYMMDD），并将其格式化为YY-MM-DD
     * 如果日期字符串的长度既不是8位也不是6位，则直接返回原始字符串，不做处理
     *
     * @param source 传入的日期字符串，期望是连续的数字表示日期
     * @return 格式化后的日期字符串，如果输入不符合预期格式，则返回原始字符串
     */
    public static String dateFormat(String source) {
        // 检查源日期字符串长度是否为8，适用于YYYYMMDD格式
        if (source.length() == 8) {
            // 使用正则表达式和捕获组来格式化字符串为YYYY-MM-DD格式
            return source.replaceFirst("(\\d{4})(\\d{2})(\\d{2})", "$1-$2-$3");
            // 检查源日期字符串长度是否为6，适用于YYMMDD格式
        } else if (source.length() == 6) {
            // 使用正则表达式和捕获组来格式化字符串为YY-MM-DD格式
            return source.replaceFirst("(\\d{2})(\\d{2})(\\d{2})", "$1-$2-$3");
        } else {
            // 如果字符串长度不符合预期，直接返回原始字符串
            return source;
        }
    }

    /**
     * 时间字符串格式化
     * 该方法旨在将数字字符串格式化为时间格式
     * 如果字符串长度为6，将其格式化为HH:MM:SS格式
     * 如果字符串长度为4，将其格式化为HH:MM格式
     * 其他情况直接返回原字符串
     *
     * @param source 待格式化的时间字符串
     * @return 格式化后的时间字符串，如果输入不符合条件则返回原字符串
     */
    public static String timeFormat(String source) {
        // 检查字符串长度是否为6，以决定是否将其格式化为HH:MM:SS
        if (source.length() == 6) {
            return source.replaceFirst("(\\d{2})(\\d{2})(\\d{2})", "$1:$2:$3");
            // 检查字符串长度是否为4，以决定是否将其格式化为HH:MM
        } else if (source.length() == 4) {
            return source.replaceFirst("(\\d{2})(\\d{2})", "$1:$2");
        } else {
            // 如果字符串长度既不是6也不是4，直接返回原字符串
            return source;
        }
    }

    // =======================================================================================
    // ================================时间日期字符串格式化=======================================
    // =======================================================================================

    /**
     * 将日期对象格式化为"yyyyMM"格式的字符串
     * 此方法用于将给定的日期对象转换为特定格式的字符串，以便于在需要日期字符串的场景下使用
     * 例如：数据库查询、文件命名、日志记录等
     *
     * @param date 日期对象，表示需要格式化的日期
     * @return 格式化后的字符串，形如"yyyyMMdd"
     */
    public static final String getFormat1(Date date) {
        // 创建一个SimpleDateFormat对象，用于格式化日期
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMM");
        // 使用SimpleDateFormat对象将日期对象格式化为字符串并返回
        return simp.format(date);
    }

    /**
     * 将日期对象格式化为"yyyy-MM"格式的字符串
     * 用于当需要以年月格式展示日期信息时
     *
     * @param date 日期对象，表示需要格式化的日期
     * @return 返回格式化后的字符串日期，格式为"yyyy-MM"
     */
    public static final String getFormat2(Date date) {
        // 创建SimpleDateFormat对象，指定输出格式为"yyyy-MM"
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM");
        // 使用SimpleDateFormat对象将日期对象格式化为字符串，并返回
        return simp.format(date);
    }

    /**
     * 将日期对象格式化为"yyyy/MM"格式的字符串
     * 用于需要以年月形式表示日期的场景
     *
     * @param date 日期对象，表示需要格式化的日期
     * @return 格式化后的字符串日期，格式为"yyyy/MM"
     */
    public static final String getFormat3(Date date) {
        // 创建SimpleDateFormat实例，指定输出格式为"yyyy/MM"
        SimpleDateFormat simp = new SimpleDateFormat("yyyy/MM");
        // 使用SimpleDateFormat实例格式化日期对象，并返回格式化后的字符串
        return simp.format(date);
    }

    /**
     * 将日期对象格式化为yyyyMMdd格式的字符串
     * 此方法用于将Java的Date对象转换为易于阅读和处理的字符串表示形式
     * 主要用途包括数据传输、文本显示等，其中日期的精确到天的表示尤为重要
     *
     * @param date 一个Date对象，代表需要格式化的日期
     * @return 返回格式化后的字符串，例如"20230101"代表2023年1月1日
     */
    public static final String getFormat4(Date date) {
        // 创建一个SimpleDateFormat实例，用于格式化日期
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMMdd");
        // 使用SimpleDateFormat实例格式化传入的Date对象，并返回格式化后的字符串
        return simp.format(date);
    }

    /**
     * 将日期对象格式化为字符串日期格式(yyyy/MM/dd)
     * 此方法用于将Java.util.Date对象转换为字符串表示形式，遵循特定格式
     * 主要用途是统一日期的字符串表示方式，以便在系统中一致地显示或记录日期信息
     *
     * @param date 日期对象，表示需要格式化的日期
     * @return 格式化后的日期字符串，格式为yyyy/MM/dd
     */
    public static final String getFormat5(Date date) {
        // 创建SimpleDateFormat实例，指定输出格式为yyyy/MM/dd
        SimpleDateFormat simp = new SimpleDateFormat("yyyy/MM/dd");
        // 使用SimpleDateFormat实例格式化传入的日期对象，并返回格式化后的字符串
        return simp.format(date);
    }

    /**
     * 将日期对象格式化为字符串日期格式（yyyy-MM-dd）
     * 此方法用于将Java日期对象转换为特定格式的字符串，
     * 以便在需要以人类可读形式显示日期时使用
     *
     * @param date 日期对象，表示要格式化的日期
     * @return 格式化后的日期字符串，格式为yyyy-MM-dd
     */
    public static final String getFormat6(Date date) {
        // 创建一个SimpleDateFormat实例，用于格式化日期
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd");
        // 使用SimpleDateFormat实例将日期对象格式化为字符串并返回
        return simp.format(date);
    }

    /**
     * 字符串日期时间格式化(yyyyMMddHHmmss )
     */
    public static final String getFormat7(Date date) {
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMMddHHmmss");
        return simp.format(date);
    }

    /**
     * 将Date对象转换为字符串日期时间格式(yyyyMMddHHmm)
     * 此方法用于将给定的Date对象格式化为特定格式的字符串，主要用于需要以紧凑格式表示日期和时间的场景
     * 选择这种格式是因为它包含了年、月、日、小时和分钟信息，适用于需要精确到分钟的时间表示
     * 不包含秒和更小的时间单位，因为对于许多应用场景来说，分钟级别的精度已经足够
     *
     * @param date 需要格式化的Date对象，它代表了一个特定的瞬间，精确到毫秒
     * @return 返回格式化的字符串，表示传入Date对象的"yyyyMMddHHmm"格式
     */
    public static final String getFormat8(Date date) {
        // 创建一个SimpleDateFormat实例，用于格式化日期和时间
        // 指定模式为"yyyyMMddhhmm"，表示年月日小时分钟
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMMddHHmm");
        // 使用SimpleDateFormat实例格式化传入的Date对象，并返回格式化后的字符串
        return simp.format(date);
    }

    /**
     * 将Date对象格式化为字符串日期时间
     * 使用固定的格式"yyyy-MM-dd HH:mm"来表示日期和时间
     * 此方法专注于将日期时间信息转换为人类可读的字符串格式
     *
     * @param date Date对象，需要格式化的日期时间
     * @return 格式化后的字符串日期时间
     */
    public static final String getFormat9(Date date) {
        // 创建一个SimpleDateFormat对象，指定输出格式
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        // 使用SimpleDateFormat对象格式化Date对象为字符串并返回
        return simp.format(date);
    }

    /**
     * 将Date对象转换为字符串日期时间格式(yyyy-MM-dd HH:mm:ss)
     * 此方法选择这种特定的格式因为它是常见且易于理解的日期时间表示形式，
     * 适用于需要同时展示日期和时间的场景
     *
     * @param date Date对象，待格式化的日期时间
     * @return 返回格式化后的字符串日期时间
     */
    public static final String getFormat10(Date date) {
        // 创建一个SimpleDateFormat对象，指定输出格式
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 使用SimpleDateFormat对象格式化Date对象为字符串并返回
        return simp.format(date);
    }

    // =======================================================================================
    // ================================时间日期字符串转换========================================
    // =======================================================================================

    /**
     * 将字符串日期格式转换为"yyyyMM"格式的Date对象
     * 此方法专注于处理特定格式的日期字符串，便于在系统中统一日期格式
     * 选择"yyyyMM"格式是因为它常用于文件命名、日期标识等场景，简洁且具有良好的可读性
     *
     * @param date 日期字符串，应符合"yyyyMM"格式，例如："202301"表示2023年1月
     * @return Date对象，表示输入的日期字符串
     * @throws Exception 如果日期字符串不符合预期格式或解析过程中出现错误
     */
    public static final Date setFormat1(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定输出格式为"yyyyMM"
        // 选择"yyyyMM"格式是因为它在很多场景下被用作日期的简写形式，如年月统计、文件命名等
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMM");
        // 使用SimpleDateFormat的parse方法将字符串转换为Date对象
        // 这里可能会抛出ParseException，但根据方法签名，所有异常都被视为Exception处理
        return simp.parse(date);
    }

    /**
     * 将字符串日期格式转换为(yyyy-MM)的Date对象
     * 此方法用于解析符合"yyyy-MM"格式的日期字符串，并将其转换为Date对象
     * 主要用于处理和日期相关的数据，以便于在程序中进行进一步的操作或存储
     *
     * @param date 日期字符串，应符合"yyyy-MM"的格式，例如："2023-10"
     * @return 返回解析后的Date对象，如果日期字符串不符合格式，则抛出异常
     * @throws Exception 如果日期字符串无法解析为"yyyy-MM"格式的日期，则抛出此异常
     */
    public static final Date setFormat2(String date) throws Exception {
        // 创建一个SimpleDateFormat对象，指定日期格式为"yyyy-MM"
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM");
        // 使用SimpleDateFormat对象解析输入的日期字符串，并返回解析后的Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串日期格式转换为(yyyy/MM)的Date对象
     * 此方法专注于处理特定格式的日期字符串，以便在程序中统一日期格式
     * 选择使用"yyyy/MM"格式，因为它适用于大多数亚洲地区，并且在日常业务中常见
     *
     * @param date 日期字符串，预期格式为"yyyy/MM"
     * @return 解析后的Date对象，表示输入的日期
     * @throws Exception 如果日期字符串不符合预期格式或无法解析，则抛出异常
     */
    public static final Date setFormat3(String date) throws Exception {
        // 创建一个SimpleDateFormat实例，指定输出格式为"yyyy/MM"
        SimpleDateFormat simp = new SimpleDateFormat("yyyy/MM");
        // 使用SimpleDateFormat实例解析输入的日期字符串，并返回解析后的Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串日期转换为Date对象，使用yyyyMMdd格式进行解析
     * 此方法专注于处理特定格式的日期字符串，适用于需要将日期字符串转换为Date对象的场景
     *
     * @param date 日期字符串，应符合yyyyMMdd格式，例如：20230101代表2023年1月1日
     * @return Date对象，表示输入的日期字符串所对应的日期
     * @throws Exception 如果日期字符串不符合格式或者解析过程中出现错误，将抛出异常
     */
    public static final Date setFormat4(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定日期格式为yyyyMMdd
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMMdd");
        // 使用SimpleDateFormat实例解析输入的日期字符串并返回Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串日期转换为Date对象，使用特定的日期格式(yyyy/MM/dd)
     * 此方法专注于处理年月日格式的字符串，确保其按照正确的日期格式被解析
     *
     * @param date 代表日期的字符串，格式应为"yyyy/MM/dd"
     * @return Date对象，表示解析后的日期
     * @throws Exception 如果字符串日期格式不正确或无法解析，将抛出异常
     */
    public static final Date setFormat5(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定日期格式为"yyyy/MM/dd"
        SimpleDateFormat simp = new SimpleDateFormat("yyyy/MM/dd");
        // 解析字符串日期，转换为Date对象并返回
        return simp.parse(date);
    }

    /**
     * 将字符串日期转换为Date对象，日期格式为yyyy-MM-dd
     * 该方法专注于处理特定格式的日期字符串，适用于需要将日期字符串转换为Date对象的场景
     *
     * @param date 日期字符串，应符合"yyyy-MM-dd"格式
     * @return Date对象，表示输入的日期
     * @throws Exception 如果日期字符串不符合指定格式，抛出异常
     */
    public static final Date setFormat6(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定日期格式为"yyyy-MM-dd"
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd");
        // 使用SimpleDateFormat实例将日期字符串解析为Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串日期时间格式转换为Date对象
     * 此方法专注于处理特定格式的日期时间字符串：yyyyMMddHHmmss
     * 它使用SimpleDateFormat进行解析，这比手动解析更方便，提高了代码的可读性和可维护性
     *
     * @param date 日期时间字符串，格式为yyyyMMddHHmmss
     * @return 解析后的Date对象
     * @throws Exception 如果解析过程中出现错误，此异常将被抛出
     */
    public static final Date setFormat7(String date) throws Exception {
        // 使用指定格式创建SimpleDateFormat实例
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMMddHHmmss");
        // 使用SimpleDateFormat实例解析输入的日期时间字符串并返回Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串日期时间转换为Date对象
     * 该方法专门用于处理格式为yyyyMMddhhmm的字符串日期时间
     * 主要用途是统一处理日期时间字符串，提高代码可读性和可维护性
     *
     * @param date 字符串日期时间，格式为yyyyMMddHHmm
     * @return 对应的Date对象
     * @throws Exception 如果字符串日期时间格式不正确或解析失败
     */
    public static final Date setFormat8(String date) throws Exception {
        // 创建SimpleDateFormat实例，指定日期时间格式
        SimpleDateFormat simp = new SimpleDateFormat("yyyyMMddHHmm");
        // 解析字符串日期时间并返回对应的Date对象
        return simp.parse(date);
    }

    /**
     * 将字符串日期时间格式转换为Date对象
     * 该方法专门用于处理格式为"yyyy-MM-dd HH:mm"的日期时间字符串
     *
     * @param date 日期时间字符串，应符合"yyyy-MM-dd HH:mm"格式
     * @return Date对象，表示输入的日期和时间
     * @throws Exception 如果输入的字符串格式不正确，无法解析为日期时间，则抛出异常
     */
    public static final Date setFormat9(String date) throws Exception {
        // 创建SimpleDateFormat实例，用于解析特定格式的日期时间字符串
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        // 使用SimpleDateFormat实例解析输入的字符串，转换为Date对象并返回
        return simp.parse(date);
    }

    /**
     * 将字符串日期时间格式转换为Date对象
     * 该方法专门用于处理格式为"yyyy-MM-dd HH:mm:ss"的日期时间字符串
     *
     * @param date 日期时间字符串，应符合"yyyy-MM-dd HH:mm:ss"格式
     * @return Date对象，表示输入的日期和时间
     * @throws Exception 如果日期时间字符串格式不正确，将抛出异常
     */
    public static final Date setFormat10(String date) throws Exception {
        // 创建SimpleDateFormat实例，用于解析日期时间字符串
        SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 解析输入的日期时间字符串并返回对应的Date对象
        return simp.parse(date);
    }
}
